Socket serveru ietvari: Praktisks ceļvedis Python SocketServer modulī

Mūsdienu savstarpēji savienotajā pasaulē socket programmēšanai ir būtiska loma komunikācijas nodrošināšanā starp dažādām lietojumprogramām un sistēmām. Python modulis SocketServer nodrošina vienkāršotu un strukturētu veidu tīkla serveru izveidei, abstrahējot lielu daļu no pamatā esošās sarežģītības. Šis ceļvedis iepazīstinās jūs ar socket servera ietvaru pamatkonceptiem, koncentrējoties uz moduļa SocketServer praktiskajiem pielietojumiem Python. Mēs aplūkosim dažādus aspektus, tostarp pamata servera iestatīšanu, vairāku klientu apstrādi vienlaicīgi un pareizā servera veida izvēli jūsu specifiskajām vajadzībām. Neatkarīgi no tā, vai veidojat vienkāršu tērzēšanas lietojumprogrammu vai sarežģītu izplatītu sistēmu, moduļa SocketServer izpratne ir būtisks solis tīkla programmēšanas apguvē Python.

Socket serveru izpratne

Socket serveris ir programma, kas klausās noteiktā portā ienākošos klientu savienojumus. Kad klients pieslēdzas, serveris pieņem savienojumu un izveido jaunu socket saziņai. Tas ļauj serverim apstrādāt vairākus klientus vienlaicīgi. Python modulis SocketServer nodrošina ietvaru šādu serveru izveidei, apstrādājot zema līmeņa informāciju par socket pārvaldību un savienojumu apstrādi.

Pamatkoncepti

• Socket: Socket ir divvirzienu komunikācijas saites galapunkts starp divām programmām, kas darbojas tīklā. Tas ir analoģisks telefona ligzdai – viena programma tiek pieslēgta socket, lai nosūtītu informāciju, un otra programma tiek pieslēgta citai socket, lai to saņemtu.
• Ports: Ports ir virtuāls punkts, kur tīkla savienojumi sākas un beidzas. Tas ir ciparu identifikators, kas atšķir dažādas lietojumprogrammas vai pakalpojumus, kas darbojas vienā mašīnā. Piemēram, HTTP parasti izmanto portu 80, un HTTPS izmanto portu 443.
• IP Adrese: IP (Interneta protokola) adrese ir ciparu marķējums, kas piešķirts katrai ierīcei, kas savienota ar datoru tīklu, kurš saziņai izmanto Interneta protokolu. Tā identificē ierīci tīklā, ļaujot citām ierīcēm tai nosūtīt datus. IP adreses ir kā pasta adreses datoriem internetā.
• TCP pret UDP: TCP (Transmission Control Protocol) un UDP (User Datagram Protocol) ir divi fundamentāli transporta protokoli, ko izmanto tīkla saziņā. TCP ir uz savienojumu orientēts, nodrošinot uzticamu, sakārtotu un kļūdu pārbaudītu datu piegādi. UDP ir bez savienojuma, piedāvājot ātrāku, bet mazāk uzticamu piegādi. Izvēle starp TCP un UDP ir atkarīga no lietojumprogrammas prasībām.

Iepazīstinām ar Python SocketServer moduli

Modulis SocketServer vienkāršo tīkla serveru izveides procesu Python, nodrošinot augsta līmeņa interfeisu ar pamatā esošo socket API. Tas abstrahē daudzas socket pārvaldības sarežģītības, ļaujot izstrādātājiem koncentrēties uz lietojumprogrammas loģiku, nevis zema līmeņa detaļām. Modulis nodrošina vairākas klases, kuras var izmantot dažādu veidu serveru izveidei, tostarp TCP serverus (TCPServer) un UDP serverus (UDPServer).

Galvenās klases SocketServer modulī

• BaseServer: Visu servera klašu bāzes klase modulī SocketServer. Tā definē pamata servera darbību, piemēram, savienojumu klausīšanos un pieprasījumu apstrādi.
• TCPServer: BaseServer apakšklase, kas implementē TCP (Transmission Control Protocol) serveri. TCP nodrošina uzticamu, sakārtotu un kļūdu pārbaudītu datu piegādi.
• UDPServer: BaseServer apakšklase, kas implementē UDP (User Datagram Protocol) serveri. UDP ir bez savienojuma un nodrošina ātrāku, bet mazāk uzticamu datu pārraidi.
• BaseRequestHandler: Bāzes klase pieprasījumu apstrādātāja klasēm. Pieprasījumu apstrādātājs ir atbildīgs par atsevišķu klientu pieprasījumu apstrādi.
• StreamRequestHandler: BaseRequestHandler apakšklase, kas apstrādā TCP pieprasījumus. Tā nodrošina ērtas metodes datu lasīšanai un rakstīšanai klienta socket kā straumēm.
• DatagramRequestHandler: BaseRequestHandler apakšklase, kas apstrādā UDP pieprasījumus. Tā nodrošina metodes datagrammu (datu pakešu) saņemšanai un nosūtīšanai.

Vienkārša TCP servera izveide

Sāksim ar vienkārša TCP servera izveidi, kas klausās ienākošos savienojumus un atbalso atpakaļ saņemtos datus klientam. Šis piemērs demonstrē SocketServer lietojumprogrammas pamata struktūru.

Piemērs: Atbalss serveris

Šeit ir kods pamata atbalss serverim:

            import SocketServer

class MyTCPHandler(SocketServer.BaseRequestHandler):
    """
    The request handler class for our server.

    It is instantiated once per connection to the server, and must
    override the handle() method to implement communication to the
    client.
    """

    def handle(self):
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        print "{} wrote:".format(self.client_address[0])
        print self.data
        # just send back the same data you received.
        self.request.sendall(self.data)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    # Create the server, binding to localhost on port 9999
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

    # Activate the server; this will keep running until you
    # interrupt the program with Ctrl-C
    server.serve_forever()

            

              
                Copy
              
            
          

Paskaidrojums:

• Mēs importējam moduli SocketServer.
• Mēs definējam pieprasījumu apstrādātāja klasi, MyTCPHandler, kas manto no SocketServer.BaseRequestHandler.
• Metode handle() ir pieprasījumu apstrādātāja kodols. Tā tiek izsaukta ikreiz, kad klients pieslēdzas serverim.
• Metodes handle() iekšienē mēs saņemam datus no klienta, izmantojot self.request.recv(1024). Šajā piemērā mēs ierobežojam maksimālos saņemtos datus līdz 1024 baitiem.
• Mēs izdrukājam klienta adresi un saņemtos datus uz konsoles.
• Mēs nosūtām saņemtos datus atpakaļ klientam, izmantojot self.request.sendall(self.data).
• Blokā if __name__ == "__main__": mēs izveidojam TCPServer instanci, piesaistot to localhost adresei un portam 9999.
• Pēc tam mēs izsaucam server.serve_forever(), lai startētu serveri un uzturētu to darboties, līdz programma tiek pārtraukta.

Atbalss servera palaišana

Lai palaistu atbalss serveri, saglabājiet kodu failā (piemēram, echo_server.py) un izpildiet to no komandrindas:

            python echo_server.py
            

              
                Copy
              
            
          

Serveris sāks klausīties savienojumus portā 9999. Pēc tam varat pieslēgties serverim, izmantojot klienta programmu, piemēram, telnet vai netcat. Piemēram, izmantojot netcat:

            nc localhost 9999
            

              
                Copy
              
            
          

Jebkas, ko ievadīsiet netcat klientā, tiks nosūtīts serverim un atbalss veidā atgriezts jums.

Vairāku klientu apstrāde vienlaicīgi

Pavedienošana (Threading)

Pavedienošana ļauj apstrādāt vairākus klientus vienlaicīgi vienā procesā. Katrs klienta savienojums tiek apstrādāts atsevišķā pavedienā, ļaujot serverim turpināt klausīties jaunus savienojumus, kamēr tiek apkalpoti citi klienti. Modulis SocketServer nodrošina klasi ThreadingMixIn, ko var pievienot servera klasei, lai iespējotu pavedienošanu.

Piemērs: Pavedienu atbalss serveris

            import SocketServer
import threading

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        cur_thread = threading.current_thread()
        response = "{}: {}".format(cur_thread.name, data)
        self.request.sendall(response)

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address

    # Start a thread with the server -- that thread will then start one
    # more thread for each request
    server_thread = threading.Thread(target=server.serve_forever)
    # Exit the server thread when the main thread terminates
    server_thread.daemon = True
    server_thread.start()

    print "Server loop running in thread:", server_thread.name

    # ... (Your main thread logic here, e.g., simulating client connections)
    # For example, to keep the main thread alive:
    # while True:
    #     pass # Or perform other tasks

    server.shutdown()

            

              
                Copy
              
            
          

Paskaidrojums:

• Mēs importējam moduli threading.
• Mēs izveidojam klasi ThreadedTCPRequestHandler, kas manto no SocketServer.BaseRequestHandler. Metode handle() ir līdzīga iepriekšējam piemēram, bet tā atbildē iekļauj arī pašreizējā pavediena nosaukumu.
• Mēs izveidojam klasi ThreadedTCPServer, kas manto gan no SocketServer.ThreadingMixIn, gan no SocketServer.TCPServer. Šis mix-in iespējo pavedienošanu serverim.
• Blokā if __name__ == "__main__": mēs izveidojam ThreadedTCPServer instanci un palaižam to atsevišķā pavedienā. Tas ļauj galvenajam pavedienam turpināt izpildi, kamēr serveris darbojas fonā.

Šis serveris tagad var apstrādāt vairākus klientu savienojumus vienlaicīgi. Katrs savienojums tiks apstrādāts atsevišķā pavedienā, ļaujot serverim vienlaicīgi atbildēt vairākiem klientiem.

Dakšošana (Forking)

Dakšošana (forking) ir vēl viens veids, kā vienlaicīgi apstrādāt vairākus klientus. Kad tiek saņemts jauns klienta savienojums, serveris dakšojas jaunam procesam, lai apstrādātu savienojumu. Katram procesam ir sava atmiņas telpa, tāpēc procesi ir izolēti viens no otra. Modulis SocketServer nodrošina klasi ForkingMixIn, ko var pievienot servera klasei, lai iespējotu dakšošanu. Piezīme: Dakšošana parasti tiek izmantota Unix līdzīgās sistēmās (Linux, macOS) un var nebūt pieejama vai piemērota Windows vidēs.

Piemērs: Dakšojošais atbalss serveris

            import SocketServer
import os

class ForkingTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        pid = os.getpid()
        response = "PID {}: {}".format(pid, data)
        self.request.sendall(response)

class ForkingTCPServer(SocketServer.ForkingMixIn, SocketServer.TCPServer):
    pass

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = ForkingTCPServer((HOST, PORT), ForkingTCPRequestHandler)
    ip, port = server.server_address

    server.serve_forever()

            

              
                Copy
              
            
          

Paskaidrojums:

• Mēs importējam moduli os.
• Mēs izveidojam klasi ForkingTCPRequestHandler, kas manto no SocketServer.BaseRequestHandler. Metode handle() atbildē iekļauj procesa ID (PID).
• Mēs izveidojam klasi ForkingTCPServer, kas manto gan no SocketServer.ForkingMixIn, gan no SocketServer.TCPServer. Šis mix-in iespējo dakšošanu serverim.
• Blokā if __name__ == "__main__": mēs izveidojam ForkingTCPServer instanci un palaižam to, izmantojot server.serve_forever(). Katrs klienta savienojums tiks apstrādāts atsevišķā procesā.

Kad klients pieslēdzas šim serverim, serveris dakšos jaunu procesu, lai apstrādātu savienojumu. Katram procesam būs savs PID, kas ļaus jums redzēt, ka savienojumus apstrādā dažādi procesi.

Izvēle starp pavedienošanu un dakšošanu

Izvēle starp pavedienošanu un dakšošanu ir atkarīga no vairākiem faktoriem, tostarp operētājsistēmas, lietojumprogrammas rakstura un pieejamajiem resursiem. Šeit ir galveno apsvērumu kopsavilkums:

• Operētājsistēma: Dakšošana parasti ir vēlams Unix līdzīgās sistēmās, savukārt pavedienošana ir biežāka Windows.
• Resursu patēriņš: Dakšošana patērē vairāk resursu nekā pavedienošana, jo katram procesam ir sava atmiņas telpa. Pavedienošana dala atmiņas telpu, kas var būt efektīvāka, taču tai ir nepieciešama arī rūpīga sinhronizācija, lai izvairītos no sacensību apstākļiem un citām paralēluma problēmām.
• Sarežģītība: Pavedienošana var būt sarežģītāka implementācijā un atkļūdošanā nekā dakšošana, īpaši, ja tiek strādāts ar kopīgiem resursiem.
• Mērogojamība: Dažos gadījumos dakšošana var būt labāk mērogojama nekā pavedienošana, jo tā var efektīvāk izmantot vairākus CPU kodolus. Tomēr procesu izveides un pārvaldības izmaksas var ierobežot mērogojamību.

Parasti, ja veidojat vienkāršu lietojumprogrammu Unix līdzīgā sistēmā, dakšošana var būt laba izvēle. Ja veidojat sarežģītāku lietojumprogrammu vai mērķējat uz Windows, pavedienošana var būt piemērotāka. Ir svarīgi ņemt vērā arī jūsu vides resursu ierobežojumus un lietojumprogrammas iespējamās mērogojamības prasības. Augsti mērogojamām lietojumprogrammām apsveriet asinhronus ietvarus, piemēram, `asyncio`, kas var piedāvāt labāku veiktspēju un resursu izmantošanu.

Vienkārša UDP servera izveide

UDP (User Datagram Protocol) ir bez savienojuma protokols, kas nodrošina ātrāku, bet mazāk uzticamu datu pārraidi nekā TCP. UDP bieži tiek izmantots lietojumprogrammām, kur ātrums ir svarīgāks par uzticamību, piemēram, straumēšanas medijiem un tiešsaistes spēlēm. Modulis SocketServer nodrošina klasi UDPServer UDP serveru izveidei.

Piemērs: UDP atbalss serveris

            import SocketServer

class MyUDPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print "{} wrote:".format(self.client_address[0])
        print data
        socket.sendto(data, self.client_address)

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.UDPServer((HOST, PORT), MyUDPHandler)

    server.serve_forever()

            

              
                Copy
              
            
          

Paskaidrojums:

• Metode handle() klasē MyUDPHandler saņem datus no klienta. Atšķirībā no TCP, UDP dati tiek saņemti kā datagramma (datu pakete).
• Atribūts self.request ir korts, kas satur datus un socket. Mēs izvelkam datus, izmantojot self.request[0], un socket, izmantojot self.request[1].
• Mēs nosūtām saņemtos datus atpakaļ klientam, izmantojot socket.sendto(data, self.client_address).

Šis serveris saņems UDP datagrammas no klientiem un atbalss veidā nosūtīs tās atpakaļ sūtītājam.

Uzlabotas tehnikas

Dažādu datu formātu apstrāde

Daudzās reālās pasaules lietojumprogrammās jums būs jāapstrādā dažādi datu formāti, piemēram, JSON, XML vai Protocol Buffers. Jūs varat izmantot Python iebūvētos moduļus vai trešo pušu bibliotēkas, lai serializētu un deserializētu datus. Piemēram, moduli json var izmantot JSON datu apstrādei:

            import SocketServer
import json

class JSONTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        try:
            data = self.request.recv(1024).strip()
            json_data = json.loads(data)
            print "Received JSON data:", json_data

            # Process the JSON data
            response_data = {"status": "success", "message": "Data received"}
            response_json = json.dumps(response_data)
            self.request.sendall(response_json)

        except ValueError as e:
            print "Invalid JSON data received: {}".format(e)
            self.request.sendall(json.dumps({"status": "error", "message": "Invalid JSON"}))

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), JSONTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

Šis piemērs saņem JSON datus no klienta, parsē tos, izmantojot json.loads(), apstrādā tos un nosūta JSON atbildi atpakaļ klientam, izmantojot json.dumps(). Iekļauta kļūdu apstrāde, lai uztvertu nederīgus JSON datus.

Autentifikācijas ieviešana

Drošām lietojumprogrammām jums būs jāievieš autentifikācija, lai pārbaudītu klientu identitāti. To var izdarīt, izmantojot dažādas metodes, piemēram, lietotājvārda/paroles autentifikāciju, API atslēgas vai digitālos sertifikātus. Šeit ir vienkāršots lietotājvārda/paroles autentifikācijas piemērs:

            import SocketServer
import hashlib

# Replace with a secure way to store passwords (e.g., using bcrypt)
USER_CREDENTIALS = {
    "user1": "password123",
    "user2": "secure_password"
}

class AuthTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        # Authentication logic
        username = self.request.recv(1024).strip()
        password = self.request.recv(1024).strip()

        if username in USER_CREDENTIALS and USER_CREDENTIALS[username] == password:
            print "User {} authenticated successfully".format(username)
            self.request.sendall("Authentication successful")
            # Proceed with handling the client request
            # (e.g., receive further data and process it)

        else:
            print "Authentication failed for user {}".format(username)
            self.request.sendall("Authentication failed")

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), AuthTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

Svarīga drošības piezīme: Iepriekš minētais piemērs ir paredzēts tikai demonstrācijas nolūkiem un nav drošs. Nekad neuzglabājiet paroles atklātā tekstā. Izmantojiet spēcīgu paroļu hešošanas algoritmu, piemēram, bcrypt vai Argon2, lai hešētu paroles pirms to glabāšanas. Turklāt apsveriet iespēju izmantot robustāku autentifikācijas mehānismu, piemēram, OAuth 2.0 vai JWT (JSON Web Tokens), ražošanas vidēs.

Žurnālēšana un kļūdu apstrāde

Pareiza žurnālēšana un kļūdu apstrāde ir būtiska servera atkļūdošanai un uzturēšanai. Izmantojiet Python moduli logging, lai ierakstītu notikumus, kļūdas un citu attiecīgu informāciju. Ieviesiet visaptverošu kļūdu apstrādi, lai eleganti apstrādātu izņēmumus un novērstu servera avārijas. Vienmēr žurnālējiet pietiekami daudz informācijas, lai efektīvi diagnosticētu problēmas.

            import SocketServer
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class LoggingTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        try:
            data = self.request.recv(1024).strip()
            logging.info("Received data from {}: {}".format(self.client_address[0], data))
            self.request.sendall(data)
        except Exception as e:
            logging.exception("Error handling request from {}: {}".format(self.client_address[0], e))
            self.request.sendall("Error processing request")

if __name__ == "__main__":
    HOST, PORT = "localhost", 9999

    server = SocketServer.TCPServer((HOST, PORT), LoggingTCPHandler)
    server.serve_forever()

            

              
                Copy
              
            
          

Šis piemērs konfigurē žurnālēšanu, lai ierakstītu informāciju par ienākošajiem pieprasījumiem un jebkādām kļūdām, kas rodas pieprasījumu apstrādes laikā. Metode logging.exception() tiek izmantota izņēmumu žurnālēšanai ar pilnu steka izsekošanu, kas var būt noderīga atkļūdošanai.

Alternatīvas SocketServer

Lai gan modulis SocketServer ir labs sākumpunkts socket programmēšanas apguvei, tam ir daži ierobežojumi, īpaši attiecībā uz augstas veiktspējas un mērogojamām lietojumprogrammām. Dažas populāras alternatīvas ietver:

• asyncio: Python iebūvētais asinhronais I/O ietvars. asyncio nodrošina efektīvāku veidu, kā apstrādāt vairākus vienlaicīgus savienojumus, izmantojot korutīnas un notikumu cilpas. Tas parasti ir vēlams mūsdienu lietojumprogrammām, kurām nepieciešama augsta vienlaicīgums.
• Twisted: Pythonā rakstīts uz notikumiem balstīts tīkla dzinējs. Twisted nodrošina plašu funkciju kopumu tīkla lietojumprogrammu veidošanai, tostarp atbalstu dažādiem protokoliem un vienlaicīguma modeļiem.
• Tornado: Python tīmekļa ietvars un asinhrona tīkla bibliotēka. Tornado ir paredzēts liela skaita vienlaicīgu savienojumu apstrādei un bieži tiek izmantots reāllaika tīmekļa lietojumprogrammu veidošanai.
• ZeroMQ: Augstas veiktspējas asinhrona ziņojumapmaiņas bibliotēka. ZeroMQ nodrošina vienkāršu un efektīvu veidu, kā veidot izplatītas sistēmas un ziņojumu rindas.

Secinājums

Python modulis SocketServer nodrošina vērtīgu ievadu tīkla programmēšanā, ļaujot jums ar relatīvu vieglumu veidot pamata socket serverus. Socket pamatkonceptu, TCP/UDP protokolu un SocketServer lietojumprogrammu struktūras izpratne ir būtiska tīkla lietojumprogrammu izstrādei. Lai gan SocketServer var nebūt piemērots visiem scenārijiem, īpaši tiem, kuriem nepieciešama augsta mērogojamība vai veiktspēja, tas kalpo kā spēcīgs pamats, lai apgūtu progresīvākas tīkla tehnikas un izpētītu alternatīvus ietvarus, piemēram, asyncio, Twisted un Tornado. Apgūstot šajā ceļvedī izklāstītos principus, jūs būsiet labi sagatavoti, lai risinātu plašu tīkla programmēšanas izaicinājumu klāstu.

Starptautiskie apsvērumi

Izstrādājot socket servera lietojumprogrammas globālai auditorijai, ir svarīgi ņemt vērā šādus internacionalizācijas (i18n) un lokalizācijas (l10n) faktorus:

• Rakstzīmju kodēšana: Nodrošiniet, lai jūsu serveris atbalstītu dažādas rakstzīmju kodēšanas, piemēram, UTF-8, lai pareizi apstrādātu teksta datus no dažādām valodām. Izmantojiet Unicode iekšēji un konvertējiet uz atbilstošo kodējumu, nosūtot datus klientiem.
• Laika zonas: Ņemiet vērā laika zonas, apstrādājot laika zīmogus un plānojot notikumus. Izmantojiet laika zonu atbalstošu bibliotēku, piemēram, pytz, lai konvertētu starp dažādām laika zonām.
• Skaitļu un datumu formatēšana: Izmantojiet lokalizētai videi atbilstošu formatēšanu, lai attēlotu skaitļus un datumus pareizā formātā dažādiem reģioniem. Šim nolūkam var izmantot Python moduli locale.
• Valodu tulkošana: Tulkojiet sava servera ziņojumus un lietotāja interfeisu dažādās valodās, lai padarītu to pieejamu plašākai auditorijai.
• Valūtas apstrāde: Strādājot ar finanšu darījumiem, nodrošiniet, lai jūsu serveris atbalstītu dažādas valūtas un izmantotu pareizus valūtas kursus.
• Juridiskā un regulējošā atbilstība: Esiet informēti par jebkādām juridiskām vai regulējošām prasībām, kas var attiekties uz jūsu servera darbību dažādās valstīs, piemēram, datu privātuma likumiem (piemēram, GDPR).

Ņemot vērā šos internacionalizācijas apsvērumus, jūs varat izveidot socket servera lietojumprogrammas, kas ir pieejamas un lietotājam draudzīgas globālai auditorijai.